經典網路研究與轉移特徵學習

林嶔 (Lin, Chin)

Lesson 8

深度學習網路發展史-醞釀時期(1)

要開始講起深度學習網路發展史，我們需要知道其中幾個重要的關鍵時刻。

– 首先第一個關鍵時刻當屬1986年由David Rumelhart、Geoffrey Hinton、Ronald Williams在1986年的研究，神經網路的實現相當於是在這個研究後才有實現的可能性。

F8_1

直到今天為止，99%以上的神經網路優化仍然採取反向傳播法(Backpropagation)進行。

– Geoffrey Hinton透過這篇研究以及後續的努力被人們尊稱為「神經網路之父」、「深度學習之父」等！

深度學習網路發展史-醞釀時期(2)

這篇研究也開啟了1986年以來所謂的「第二代人工智慧革命」，然而此時由於梯度消失問題的存在以及計算資源的限制，我們無法訓練過深的網路，從而限制了他的準確性。

– 另外在這個年代的神經網路由於結構較為簡單，因此並沒有辦法做出任意形式的輸入/輸出映射，所以與一般統計方法差異有限。而大約在1990年代開始，統計學家在電腦的輔助下發展出了許多準確性遠遠超越多層感知機(Multilayer Perceptron，MLP)，這個時代的重大突破如下：

支持向量機(Support Vector Machine，SVM) - 這可以說是當代在數理統計上最創新的大作，分類效果也極佳

F8_2

隨機森林(Random Forest，RF)
梯度提升機(Gradient Bboosting Machine)

這三者直到目前為止都可以說是純數值預測(X/Y皆為數值矩陣)的最佳選擇，神經網路的系列模型直到今天也無法超越他們。

深度學習網路發展史-醞釀時期(3)

由於1990年代幾個重要統計預測工具的出現，導致神經網路必須另尋出路，而突破的關鍵就在於非數值預測(例如：圖像→類別)。

– 我們在前面的課程中已經講到了，Yann Lecun在1989年所發展的卷積神經網路(Convolutional Neural Network，CNN)做到了這一點，而Yann Lecun也通過這一個重要的成就被人稱為「卷積神經網路之父」！

F8_3

F6_9

深度學習網路發展史-醞釀時期(4)

在2000年代，這時候學術界的主流是在於純數值預測的(並非當時人們不想做非數值預測，只是相關條件尚未備齊)，而使用反向傳播法所優化的神經網路受限於梯度消失問題導致深度不足，從而無法跟支持向量機、隨機森林、梯度提升機等方法相提並論。

– 在這個年代只有Geoffrey Hinton堅持了下來，他試圖提出其他的優化方法來解決反向傳播法所遇到的梯度消失問題，並在2006年成功的利用分層訓練再組合起來的方式訓練了一隻「深度神經網路」(其實也不超過10層)。

F8_4

這篇發表在Science中的論文第一次提到了深度學習(Deep Learning)這個字眼，儘管現在看來他提出的方法已被歷史洪流給淘汰，但這可以說是引導人們走向深度學習的經典文獻。

深度學習網路發展史-醞釀時期(5)

在深度學習領域，演算法只能算是引擎，而數據可以說是石油。沒有石油的加入，引擎是沒辦法體現它的性能的！

– 事實上我們從事後的角度來說，深度學習是一個需要數據量才能體現出的強大算法，假設我們一直沒有足夠的數據量，那深度學習將永無抬頭之日！

F8_5

即使到了現在，一個單純蒐集數據的研究案仍然不太可能取得計劃支持，但這項重要的工作總得有人做。史丹佛大學的李飛飛從2005年開始堅持下來努力做這件事情，並於2007年創辦ImageNet，他收集大量帶有標註信息的圖片數據供電腦視覺模型訓練，而每年將會利用其資料進行ILSVRC圖像識別競賽。

F8_6

他在2009年CVPR所發表的研究可以說是這一波深度學習突破中最重要的基石！

F8_7

深度學習網路發展史-奠基時期(1)

我們已經知道了在李飛飛的努力下，從2010年開始舉辦ImageNet Large Scale Visual Recognition Challenge (ILSVRC)，這項比賽提供了巨量的數據以及一個客觀平台比較各種演算法在圖像識別任務中的表現。

– 下面這張圖是每一年的冠軍演算法，我們可以看到在2012年以前，這項比賽大多是由SVM、隨機森林等方法獲得冠軍，但自2012年以來卷積神經網路就席捲了ILSVRC之後所有的冠軍。

F8_8

整個近代的深度學習網路發展史與這個比賽的結果息息相關，我們將跟著這個軌跡了解他的演化。而2012年那個驚天動地的突破當然就屬Alex Krizhevsky、Ilya Sutskever以及Geoffrey Hinton所提出的AlexNet了！

F8_9

深度學習網路發展史-奠基時期(2)

讓我們好好閱讀Alex Krizhevsky、Ilya Sutskever以及Geoffrey Hinton所發表的ImageNet Classification with Deep Convolutional Neural Networks，來了解他們成功的原因。
AlexNet基本上是LeNet的一種更深更寬的版本，他的網路架構如下：

F8_10

整個網路結構的創新之處基本上較小，然而身為一個劃時代的深度學習模型，我們表列下所有當時最先進的觀念：

使用ReLU做為非線性變換的激活函數 - 這點可以說是小幅度的解決了梯度消失問題，使網路總深度達到了8層
使用Dropout技術 - 這可以說是整個研究最創新的點，一定程度避免了過度擬和的危害
使用overlap的max pooling - 這是一個新的觀念，但實現上並沒有非常困難
數據增強 - 這個研究所使用的數據增強技術即使到今天都可以算是非常完整，包含了裁減、旋轉、翻轉、縮放、ZCA白化等一系列操作
使用GPU加速深度卷積網絡的訓練 - 這在當時是一個門檻較高且大家沒有想到的方向，有效的加速了神經網路的訓練
提出了一種叫做局部響應歸一化(Local response normalization，LRN)層 - 這是一種模仿生物學中相鄰的神經元有較強的訊號時會抑制旁邊較弱訊號的手段，然而後續的研究被證明用處不大

仔細研究後你會發現整個AlexNet的技術創新點可以說是幾乎沒有(儘管他在整個網路都用了當時最先進的觀念所設計)，而他最大的貢獻是重新啟用了在當時人們都覺得極度浪費運算資源且已被學界幾乎淘汰的卷積神經網路，並在ImageNet這種巨量資料的環境下證實了他強大的效果。

– Geoffrey Hinton也就是因為在神經網路的發展史中連續出現在3個關鍵時刻，而被人們尊稱為「神經網路之父」、「深度學習之父」！

深度學習網路發展史-奠基時期(3)

AlexNet在2012年底所掀起的風暴有著跨時代的影響力，從2013年起幾乎所有的電腦視覺研究室都將目光重新聚焦回卷積神經網路，然而這個時候重點研究者仔細檢視AlexNet之後，卻發現整個網路雖然是依循著視覺機制建立，但似乎大多數的構件都是屬於線性預測結構。

– 然而在之前的研究早已證實非線性的結構有助於模擬更複雜的函數模型，因此我們必須在網路內多增加更多非線性的結構以利預測！

這裡要提到一個發表於2014年ICLR由新加坡國立大學的林敏、陳強與顏水成的研究：Network In Network

F8_11

這篇研究所提出最重要的觀點在於我們在做卷積運算時，必須在這裡將其從原來的線性變換轉變為類似於MLP的結構：

而最重要的是這樣的實現其實非常簡單，也就是在n×n的卷積核之後連續堆疊1×1的卷積核就能做到了！

– 這篇研究最重要的貢獻在於提出並以實驗證明了1×1的卷積核的好處，未來的網路大量運用了這一觀念在Model Architecture之中。時至今日，目前大多數最先進的網路中1×1的卷積核的使用量甚至都超過其他維度的卷積核使用！

深度學習網路發展史-奠基時期(4)

在同個時期，牛津大學計算機視覺組(Visual Geometry Group)和DeepMind也一起研發新型的網路試圖在2014年的ILSVRC中取得好成績，而當時最困擾研究者的問題在於卷積神經網路的設計。

– 回頭看看AlexNet的結構，你是否難以理解到底哪裡應該使用11×11的卷積核，而那裡又該用3×3或是5×5呢?這導致定義Model Architecture的選擇過於發散，因此他們做了一個重要的實驗來解決這個問題。

Karen Simonyan與Andrew Zisserman在2014年發表了研究：Very Deep Convolutional Networks for Large-Scale Image Recognition，試圖利用堆疊3×3的卷積核來解決這個問題。

F8_13

使用3×3的卷積核來替代5×5的卷積核的邏輯是從降維效率來思考的，如下圖所示，兩個3x3的卷積核串聯後相當於1個5x5的卷積核：

F8_14

基於這樣的概念，這篇研究嘗試了一系列的Model Architecture來看看各種構件的效果：

F8_15

在這樣的研究中，最好的模型是最後的兩個D與E的模型，而他們之後分別被稱為VGG-16以及VGG-19，其中VGG-19又被稱為VGGNet並於2014年的ILSVRC中僅以些微的落差取得了亞軍的成績。

– 這篇研究透過比較了上述6個神經網路，告訴了我們幾個未來設計Model Architecture的重要事項：

越深的網絡效果通常越好
1x1的卷積核也顯著提升效能(與前面的研究結論相同)
局部響應歸一化層對網路的性能提升沒什麼幫助

當然這個大研究所告訴我們的事情不只這些，他還研究了一系列其他的議題，包含權重初始化、數據擴增、不同尺度圖片堆論效果的議題，有興趣的人能再進一步閱讀論文。

深度學習網路發展史-奠基時期(5)

也是在同個時期，Google研究院在當年度訓練出了一個22層深的網路GoogLeNet(又稱Inception Net)，是當時比賽中最深的一個網路，而他也順利的以93.3%的準確度於當年奪冠，並隨後於2015年所發表的研究：Going Deeper with Convolutions提到了他們如何實現這個網路的細節想法。

F8_16

這個網路在訓練時期的特殊結構我們在上一節課已經提到過了(改寫loss function提供梯度通道給淺層權重)，但他們更重要的貢獻在於提出了一種多通道網路的概念。
由於Google團隊與前面的VGG團隊同時要在2014年的ILSVRC競爭排名，所以當時研究資訊並未互通，而Google團隊同樣面對到了Model Architecture的設計問題，他們並不清楚在什麼時刻使用3x3、5x5的卷積核或是其他結構比較恰當，因此他們提出了一種叫做Inception Module的Module：

F8_17

這個Module的設計邏輯在於，他們認為卷積神經網路成功的關鍵在於1x1、3x3、5x5的卷積層以及Pooling層，而由於並不清楚什麼時刻應該使用什麼樣子的結構，所以索性就全部使用，讓網路自己決定該在什麼時刻選擇什麼樣子的結構。

– 也由於前面Network In Network的重要貢獻，最終的Inception Module在每一個通道上都加上了一個1x1卷積層以達到非線性擬合的目標：

F8_18

這個研究最重要的貢獻在於將Model Architecture的設計又再次的簡化，轉變為只要設計「初始特徵擷取結構」、「重複循環的Module」、「預測輸出結構」等三個部分就可以完成。

深度學習網路發展史-奠基時期(6)

2014年可以說是百家爭鳴的時刻，並且當時的深度學習仍然受著「梯度消失問題」所困擾，所以優化方法也是被大家深入研究，期望透過優化方法的改進解決這個問題。

– Diederik P. Kingma與Jimmy Lei Ba所提出的研究：Adam: A Method for Stochastic Optimization提出了著名的Adam

F8_19

這個方便的方法至今仍是很多研究的首選，儘管後面有許多人發現在精心調整參數後的SGD優化效果往往較Adam更好，但誰有這麼多時間對網路精心調整?

深度學習網路發展史-奠基時期(7)

在2015年，剛拿下2014年冠軍的Google團隊並未對他們已所取得的成就感到滿意，反而不斷的試圖進一步超越原來自己所提出的Inception Net，並提出一系列的改版已增加他的準確度。

– 因此，在2014年獲得冠軍的那個網路被稱作Inception v1 net，而在2015年時Google團隊在之後又開發出了Inception v2 net以及Inception v3 net。

Inception v2 net所用到的技術就是我們在第五節課已經提到過的「批量標準化」(Batch normalization)，兩位Google的研究員Sergey Ioffe以及Christian Szegedy在2015年所發表的研究：Batch Normalization: Accelerating Deep Network Training by Reducing Internal Covariate Shift第一次提到了這個想法。

F8_20

– 如同之前所提到的，在2014年底時Inception v1 net已經取得了正確率93.3%的成績，這篇研究僅在GoogleNet的基礎上並加上批量標準化技術就達到了正確率95.2%，這是史上第一篇超越人類正確率(~95.0%)的研究。

Inception Module的整個進化軌跡如下：

F8_21

簡單來說，除了在CONV後先接上BN再接上ReLU之外，v2相較於v1的演進是借鑒了VGGNet的成功之處，利用了兩個過2個3x3的卷積核取代5x5的卷積核；而到了v3則是更進一步的將3x3卷積拆成1x3卷積和3x1卷積。

– Google團隊在開發出Inception v3 net之後就將其投入至2015年的ILSVRC之中，然而由於研究突破相對小，並且同一次比賽遇到了深度學習目前為止史上最大的核彈級突破，因此就淹沒於歷史的長河之中…

深度學習網路發展史-爆發時期(1)

在2015年底的ILSVRC，人工智慧領域在2012年之後又再次發生了一件將被載入史冊的重大突破：微軟亞洲研究院何愷明所領軍的團隊，他們發展出的ResNet將錯誤率降低至3.57%，大幅超越了2014年度的冠軍GoogleNet的6.7%以及人類平均的5.0%。

– 比起競賽獲勝並正式超越人類之外更重要的意義是，我們首次真正意義上的解決了梯度消失問題，而他們所發展的Residual Learning成功地訓練了一隻1000層深的網路，並且同一個時間幾乎沒有團隊有能力訓練超過50層的神經網路。

– 這個核彈級的研究：Deep Residual Learning for Image Recognition在所有人的引頸盼望之下，發表於2016年的CVPR並理所當然的獲得了該研討會的最佳會議論文獎：

F8_22

而他所提出的概念之簡單，使他提出的概念在2016年起所有的網路中都開始使用Residual Architecture：

F8_23

而這個核彈級的研究最誇張的地方在於，他僅僅只使用了Residual Learning的概念在其網路之中，並捨棄了所有小幅提升網路性能的所有技巧(多通道的設計等)，卻仍然以輾壓級的優勢奪下了2015年ILSVRC的冠軍。這是在ResNet中所使用的Residual Module：

F8_24

在這個研究公開後，Google團隊馬上根據他的概念擴展原來的Inception Module並發展出Inception v4 net，並發表研究：Inception-v4, Inception-ResNet and the Impact of Residual Connections on Learning，進一步將錯誤率降低至3.08%

深度學習網路發展史-爆發時期(2)

由於ResNet的橫空出世，所有原先理論可行實際難以執行的研究紛紛取得了重大的突破。在很久以前我們一直提到神經網路的厲害之處在於它能夠做出任何形式的輸入/輸出預測，而神經網路得厲害之處在於它的複雜性能夠逼近幾乎任何函數從而找到任意形式輸入/輸出的預測函數。

– 然而在梯度消失問題存在的時刻，我們根本無法創造出足夠複雜(夠深)的神經網路，從而使得某些非常困難的預測難以做到，像是物件識別(Object detection)。

物件識別相較於圖像分類問題的困難之處在於，我們的輸出必須準確的預測出不等數量的物件，並準確指出他的位置，也因此在Residual Learning的概念出現之前，即便有人想要用卷積神經網路來進行物件識別任務，也需要結合多種不同的模型才能準確的做到這個任務。

F8_25

而在ResNet出現之後，之前所有的物件識別模型看起來像是智障。而Joseph Redmon所提出研究：You Only Look Once: Unified, Real-Time Object Detection中所提到的的YOLO架構僅僅修正了卷積神經網路的輸出層，在經過持續的研究之後，到2018年為止已經幾乎沒有任何卷積神經網路以外的演算法同時在「速度」以及「準確度」上勝過他！

F8_26

這個YOLO架構相當於把物件識別問題看成一個回歸問題，透過線性回歸預測物件的邊框從而達到物件識別的效果：

F8_27

而另外，我們也能透過卷積神經網路做到Segmentation的效果，而關鍵文獻是Jonathan Long、Evan Shelhamer以及Trevor Darrell於2015年提出的研究：Fully Convolutional Networks for Semantic Segmentation

F8_36

– 這是他能達到的效果：

F8_35

深度學習網路發展史-爆發時期(3)

除了圖像方面的應用，我們也可以將深度學習技術應用於自然語言上，而這裡所用到的關鍵技術是詞嵌入(Word Embedding)，比較知名的是2013年的研究Efficient Estimation of Word Representations in Vector Space所提出的word2vec模型

F8_32

這項技術的概念是能將詞彙轉變為向量表示，並且相似的語彙在向量空間中會較為靠近。而這項技術將有辦法將一個句子轉變為一個矩陣，從而讓神經網路能夠應用：

F8_33

而透過這項研究將文字與圖像的接軌之後，我們不但能這樣做文意分類，更能做出一些以前想都不敢想的事情，像是讓機器學會看圖說話：

F8_34

深度學習網路發展史-爆發時期(4)

另外既然是能做出任意形式的輸入/輸出預測，我們有沒有可能隨機輸出一些亂數並讓他產生一些有意義的資訊?

F8_28

Ian J. Goodfellow所提出的研究：Generative Adversarial Networks用一種很特殊的方法解決了這個問題。

F8_29

對抗生成網路(Generative Adversarial Networks，GAN)的基本架構如下，主要是透過兩個網路的互相競賽而產生上述的效果。生成網路負責產生一張假的圖片以騙過辨別網路，而辨別網路必須有能力分辨圖片的真偽，在經過數個循環之後生成網路為了能夠騙過辨別網路，就有能力產生出以假亂真的圖片：

F8_30

而這個對抗生成網路具有多種變形並且應用範圍極廣，比較典型的例子是風格轉換如將風景畫轉為藝術畫，或者是將語音變換腔調等

F8_31

也有研究透過他的協助，成功做到在沒有平行語料的情形下做到機器翻譯：Unsupervised Neural Machine Translation with Weight Sharing！

深度學習網路發展史-爆發時期(5)

最後再讓我們介紹一個加強深度神經網路預測能力的利器：Squeeze-and-Excitation mechanism。

– 這是在2015年的ResNet後，最後一個能大幅提升神經網路預測能力的結構，這個結構在2017年最後一屆的ILSVRC一舉奪冠並再度刷新了人類史上最佳的表現，他的細節被公布在自動駕駛公司Momenta在2017年所發表的論文：Squeeze-and-Excitation Networks之中。

這是Squeeze-and-Excitation Module的結構，他相當於對原來的Residual部分做一些加權並抑制雜訊，從而使網路避免被雜訊干擾。

F8_37

儘管這個研究還需要時間的檢驗，但目前來看這個方法確實有能力提升幾乎任何既有網路的能力。

深度學習網路發展史-爆發時期(6)

除了上面講得這些經典文獻之外，深度學習領域還有許多重要的研究讓模型變的更準以及更小，下面還有一些經典文獻可供學習：

– 模型準確性研究

Densely Connected Convolutional Networks(2016年發表，引用次數超過750次)
Xception: Deep Learning with Depthwise Separable Convolutions(2016年發表，引用次數超過200次)
Dual Path Networks(2017年發表，引用次數超過300次)

– 模型輕量化研究

SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <0.5MB model size(2016年發表，引用次數超過500次)
MobileNets: Efficient Convolutional Neural Networks for Mobile Vision Applications(2017年發表，引用次數超過350次)
ShuffleNet: An Extremely Efficient Convolutional Neural Network for Mobile Devices(2017年發表，引用次數超過100次)
MobileNetV2: Inverted Residuals and Linear Bottlenecks(2018年發表)

利用經典模型的model進行預測(1)

上述這些經典模型在ImageNet上訓練的結果，我們很容易就可以在網路上找到，而mxnet也提供了Model zoo可供下載

– 我們可以下載resnet-18模型進行預測，編號與Label對照表請訪問這裡下載(你可以下載中文版的)

library(mxnet)
library(imager)
library(magrittr)

#Load a pre-training residual network model

res_model = mx.model.load("model/resnet-18", 0)
res_sym = mx.symbol.load("model/resnet-18-symbol.json")
label_names = readLines("model/synset.txt")

#Define image processing functions

preproc.image <- function(im) {
  resized <- resize(im, 224, 224)
  resized <- as.array(resized) * 255
  # Reshape to format needed by mxnet (width, height, channel, num)
  dim(resized) <- c(224, 224, 3, 1)
  return(resized)
}

#Read image # Display image

img <- load.image(system.file("extdata/parrots.png", package="imager"))

#Pre-processing

normed <- preproc.image(img)

#Display image

par(mar=rep(0,4))
plot(NA, xlim = c(0.04, 0.96), ylim = c(0.04, 0.96), xaxt = "n", yaxt = "n", bty = "n")
rasterImage(img, 0, 0, 1, 1, interpolate=FALSE)

#Predict

prob <- predict(res_model, X = normed, ctx = mx.cpu())
cat(paste0(label_names[which.max(prob)], ': ', formatC(max(prob), 4, format = 'f'), '\n'))

## n01818515 macaw: 0.9956

準嗎?你也可以試試看隨便下載一張圖片來看看！

利用經典模型的model進行預測(2)

儘管這個resnet-18看起來滿準的，但我們並不知道他的運算過程，讓我們將他的結構拆開來看。

– 你可能不清楚這個下載來的網路結構長甚麼樣子，可以用函數「graph.viz」看看：

res_sym = mx.symbol.load("model/resnet-18-symbol.json")
graph.viz(res_sym)

而他的結果如下：

F8_38

利用經典模型的model進行預測(3)

讓我們試著一行一行來重現resnet-18的架構，而用R語言定義的MxNet的Model Architecture如下：

– 你可能會不清楚裡面細節參數是怎樣知道的，可以用記事本打開JSON檔案進行查看。

# Model Architecture

# 224×224

data <- mx.symbol.Variable(name = 'data')
bn_data <- mx.symbol.BatchNorm(data = data, eps = "2e-05", name = 'bn_data')

# 112×112

conv0 <- mx.symbol.Convolution(data = bn_data, no_bias = TRUE, name = 'conv0',
                               kernel = c(7, 7), pad = c(3, 3), stride = c(2, 2), num_filter = 64)
bn0 <- mx.symbol.BatchNorm(data = conv0, fix_gamma = FALSE, eps = "2e-05", name = 'bn0')
relu0 <- mx.symbol.Activation(data = bn0, act_type = "relu", name = 'relu0')

# 56×56

# stage1_unit1

pooling0 <- mx.symbol.Pooling(data = relu0, pool_type = "max", name = 'pooling0',
                              kernel = c(3, 3), pad = c(1, 1), stride = c(2, 2))
stage1_unit1_bn1 <- mx.symbol.BatchNorm(data = pooling0, fix_gamma = FALSE, eps = "2e-05", name = 'stage1_unit1_bn1')
stage1_unit1_relu1 <- mx.symbol.Activation(data = stage1_unit1_bn1, act_type = "relu", name = 'stage1_unit1_relu1')
stage1_unit1_conv1 <- mx.symbol.Convolution(data = stage1_unit1_relu1, no_bias = TRUE, name = 'stage1_unit1_conv1',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 64)
stage1_unit1_bn2 <- mx.symbol.BatchNorm(data = stage1_unit1_conv1, fix_gamma = FALSE, eps = "2e-05", name = 'stage1_unit1_bn2')
stage1_unit1_relu2 <- mx.symbol.Activation(data = stage1_unit1_bn2, act_type = "relu", name = 'stage1_unit1_relu2')
stage1_unit1_conv2 <- mx.symbol.Convolution(data = stage1_unit1_relu2, no_bias = TRUE, name = 'stage1_unit1_conv2',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 64)

stage1_unit1_sc <- mx.symbol.Convolution(data = stage1_unit1_relu1, no_bias = TRUE, name = 'stage1_unit1_sc',
                                         kernel = c(1, 1), pad = c(0, 0), stride = c(1, 1), num_filter = 64)

elemwise_add_plus0 <- mx.symbol.broadcast_plus(lhs = stage1_unit1_conv2, rhs = stage1_unit1_sc, name = 'elemwise_add_plus0')

# stage1_unit2

stage1_unit2_bn1 <- mx.symbol.BatchNorm(data = elemwise_add_plus0, fix_gamma = FALSE, eps = "2e-05", name = 'stage1_unit2_bn1')
stage1_unit2_relu1 <- mx.symbol.Activation(data = stage1_unit2_bn1, act_type = "relu", name = 'stage1_unit2_relu1')
stage1_unit2_conv1 <- mx.symbol.Convolution(data = stage1_unit2_relu1, no_bias = TRUE, name = 'stage1_unit2_conv1',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 64)
stage1_unit2_bn2 <- mx.symbol.BatchNorm(data = stage1_unit2_conv1, fix_gamma = FALSE, eps = "2e-05", name = 'stage1_unit2_bn2')
stage1_unit2_relu2 <- mx.symbol.Activation(data = stage1_unit2_bn2, act_type = "relu", name = 'stage1_unit2_relu2')
stage1_unit2_conv2 <- mx.symbol.Convolution(data = stage1_unit2_relu2, no_bias = TRUE, name = 'stage1_unit2_conv2',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 64)

elemwise_add_plus1 <- mx.symbol.broadcast_plus(lhs = stage1_unit2_conv2, rhs = elemwise_add_plus0, name = 'elemwise_add_plus1')

# 28×28

# stage2_unit1

stage2_unit1_bn1 <- mx.symbol.BatchNorm(data = elemwise_add_plus1, fix_gamma = FALSE, eps = "2e-05", name = 'stage2_unit1_bn1')
stage2_unit1_relu1 <- mx.symbol.Activation(data = stage2_unit1_bn1, act_type = "relu", name = 'stage2_unit1_relu1')
stage2_unit1_conv1 <- mx.symbol.Convolution(data = stage2_unit1_relu1, no_bias = TRUE, name = 'stage2_unit1_conv1',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(2, 2), num_filter = 128)
stage2_unit1_bn2 <- mx.symbol.BatchNorm(data = stage2_unit1_conv1, fix_gamma = FALSE, eps = "2e-05", name = 'stage2_unit1_bn2')
stage2_unit1_relu2 <- mx.symbol.Activation(data = stage2_unit1_bn2, act_type = "relu", name = 'stage2_unit1_relu2')
stage2_unit1_conv2 <- mx.symbol.Convolution(data = stage2_unit1_relu2, no_bias = TRUE, name = 'stage2_unit1_conv2',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 128)

stage2_unit1_sc <- mx.symbol.Convolution(data = stage2_unit1_relu1, no_bias = TRUE, name = 'stage2_unit1_sc',
                                         kernel = c(1, 1), pad = c(0, 0), stride = c(2, 2), num_filter = 128)

elemwise_add_plus2 <- mx.symbol.broadcast_plus(lhs = stage2_unit1_conv2, rhs = stage2_unit1_sc, name = 'elemwise_add_plus2')

# stage2_unit2

stage2_unit2_bn1 <- mx.symbol.BatchNorm(data = elemwise_add_plus2, fix_gamma = FALSE, eps = "2e-05", name = 'stage2_unit2_bn1')
stage2_unit2_relu1 <- mx.symbol.Activation(data = stage2_unit2_bn1, act_type = "relu", name = 'stage2_unit2_relu1')
stage2_unit2_conv1 <- mx.symbol.Convolution(data = stage2_unit2_relu1, no_bias = TRUE, name = 'stage2_unit2_conv1',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 128)
stage2_unit2_bn2 <- mx.symbol.BatchNorm(data = stage2_unit2_conv1, fix_gamma = FALSE, eps = "2e-05", name = 'stage2_unit2_bn2')
stage2_unit2_relu2 <- mx.symbol.Activation(data = stage2_unit2_bn2, act_type = "relu", name = 'stage2_unit2_relu2')
stage2_unit2_conv2 <- mx.symbol.Convolution(data = stage2_unit2_relu2, no_bias = TRUE, name = 'stage2_unit2_conv2',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 128)

elemwise_add_plus3 <- mx.symbol.broadcast_plus(lhs = stage2_unit2_conv2, rhs = elemwise_add_plus2, name = 'elemwise_add_plus3')

# 14×14

# stage3_unit1

stage3_unit1_bn1 <- mx.symbol.BatchNorm(data = elemwise_add_plus3, fix_gamma = FALSE, eps = "2e-05", name = 'stage3_unit1_bn1')
stage3_unit1_relu1 <- mx.symbol.Activation(data = stage3_unit1_bn1, act_type = "relu", name = 'stage3_unit1_relu1')
stage3_unit1_conv1 <- mx.symbol.Convolution(data = stage3_unit1_relu1, no_bias = TRUE, name = 'stage3_unit1_conv1',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(2, 2), num_filter = 256)
stage3_unit1_bn2 <- mx.symbol.BatchNorm(data = stage3_unit1_conv1, fix_gamma = FALSE, eps = "2e-05", name = 'stage3_unit1_bn2')
stage3_unit1_relu2 <- mx.symbol.Activation(data = stage3_unit1_bn2, act_type = "relu", name = 'stage3_unit1_relu2')
stage3_unit1_conv2 <- mx.symbol.Convolution(data = stage3_unit1_relu2, no_bias = TRUE, name = 'stage3_unit1_conv2',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 256)

stage3_unit1_sc <- mx.symbol.Convolution(data = stage3_unit1_relu1, no_bias = TRUE, name = 'stage3_unit1_sc',
                                         kernel = c(1, 1), pad = c(0, 0), stride = c(2, 2), num_filter = 256)

elemwise_add_plus4 <- mx.symbol.broadcast_plus(lhs = stage3_unit1_conv2, rhs = stage3_unit1_sc, name = 'elemwise_add_plus4')

# stage3_unit2

stage3_unit2_bn1 <- mx.symbol.BatchNorm(data = elemwise_add_plus4, fix_gamma = FALSE, eps = "2e-05", name = 'stage3_unit2_bn1')
stage3_unit2_relu1 <- mx.symbol.Activation(data = stage3_unit2_bn1, act_type = "relu", name = 'stage3_unit2_relu1')
stage3_unit2_conv1 <- mx.symbol.Convolution(data = stage3_unit2_relu1, no_bias = TRUE, name = 'stage3_unit2_conv1',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 256)
stage3_unit2_bn2 <- mx.symbol.BatchNorm(data = stage3_unit2_conv1, fix_gamma = FALSE, eps = "2e-05", name = 'stage3_unit2_bn2')
stage3_unit2_relu2 <- mx.symbol.Activation(data = stage3_unit2_bn2, act_type = "relu", name = 'stage3_unit2_relu2')
stage3_unit2_conv2 <- mx.symbol.Convolution(data = stage3_unit2_relu2, no_bias = TRUE, name = 'stage3_unit2_conv2',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 256)

elemwise_add_plus5 <- mx.symbol.broadcast_plus(lhs = stage3_unit2_conv2, rhs = elemwise_add_plus4, name = 'elemwise_add_plus5')

# 7×7

# stage4_unit1

stage4_unit1_bn1 <- mx.symbol.BatchNorm(data = elemwise_add_plus5, fix_gamma = FALSE, eps = "2e-05", name = 'stage4_unit1_bn1')
stage4_unit1_relu1 <- mx.symbol.Activation(data = stage4_unit1_bn1, act_type = "relu", name = 'stage4_unit1_relu1')
stage4_unit1_conv1 <- mx.symbol.Convolution(data = stage4_unit1_relu1, no_bias = TRUE, name = 'stage4_unit1_conv1',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(2, 2), num_filter = 512)
stage4_unit1_bn2 <- mx.symbol.BatchNorm(data = stage4_unit1_conv1, fix_gamma = FALSE, eps = "2e-05", name = 'stage4_unit1_bn2')
stage4_unit1_relu2 <- mx.symbol.Activation(data = stage4_unit1_bn2, act_type = "relu", name = 'stage4_unit1_relu2')
stage4_unit1_conv2 <- mx.symbol.Convolution(data = stage4_unit1_relu2, no_bias = TRUE, name = 'stage4_unit1_conv2',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 512)

stage4_unit1_sc <- mx.symbol.Convolution(data = stage4_unit1_relu1, no_bias = TRUE, name = 'stage4_unit1_sc',
                                         kernel = c(1, 1), pad = c(0, 0), stride = c(2, 2), num_filter = 512)

elemwise_add_plus6 <- mx.symbol.broadcast_plus(lhs = stage4_unit1_conv2, rhs = stage4_unit1_sc, name = 'elemwise_add_plus6')

# stage4_unit2

stage4_unit2_bn1 <- mx.symbol.BatchNorm(data = elemwise_add_plus6, fix_gamma = FALSE, eps = "2e-05", name = 'stage4_unit2_bn1')
stage4_unit2_relu1 <- mx.symbol.Activation(data = stage4_unit2_bn1, act_type = "relu", name = 'stage4_unit2_relu1')
stage4_unit2_conv1 <- mx.symbol.Convolution(data = stage4_unit2_relu1, no_bias = TRUE, name = 'stage4_unit2_conv1',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 512)
stage4_unit2_bn2 <- mx.symbol.BatchNorm(data = stage4_unit2_conv1, fix_gamma = FALSE, eps = "2e-05", name = 'stage4_unit2_bn2')
stage4_unit2_relu2 <- mx.symbol.Activation(data = stage4_unit2_bn2, act_type = "relu", name = 'stage4_unit2_relu2')
stage4_unit2_conv2 <- mx.symbol.Convolution(data = stage4_unit2_relu2, no_bias = TRUE, name = 'stage4_unit2_conv2',
                                            kernel = c(3, 3), pad = c(1, 1), stride = c(1, 1), num_filter = 512)

elemwise_add_plus7 <- mx.symbol.broadcast_plus(lhs = stage4_unit2_conv2, rhs = elemwise_add_plus6, name = 'elemwise_add_plus7')

# Final

bn1 <- mx.symbol.BatchNorm(data = elemwise_add_plus7, fix_gamma = FALSE, eps = "2e-05", name = 'bn1')
relu1 <- mx.symbol.Activation(data = bn1, act_type = "relu", name = 'relu1')
pool1 <- mx.symbol.Pooling(data = relu1, pool_type = "avg", name = 'pool1',
                           kernel = c(7, 7), pad = c(0, 0), stride = c(7, 7))
flatten0 <- mx.symbol.Flatten(data = pool1, name = 'flatten0')
fc1 <- mx.symbol.FullyConnected(data = flatten0, num_hidden = 1000, name = 'fc1')
softmax <- mx.symbol.softmax(data = fc1, axis = 1, name = 'softmax')

要怎樣確定我們寫下來的是正確的呢，你可以把物件「res_model」裡面的symbol換掉，如果還能運行且答案相同就代表正確！

res_model$symbol <- softmax

prob <- predict(res_model, X = normed, ctx = mx.cpu())
cat(paste0(label_names[which.max(prob)], ': ', formatC(max(prob), 4, format = 'f'), '\n'))

## n01818515 macaw: 0.9956

利用經典模型的model進行預測(4)

能夠進行預測還不夠，在ResNet架構中進入Softmax前最後一層的數值是描述圖像最重要的特徵，而有許多人經常利用這些Pre-training的model對圖像進行特徵萃取，再後續運用這些特徵進行之後的預測。

– 我們可以利用下列程式碼把他取出flatten0的輸出來，需要特別注意的是，由於網路並不會用到fc1_weight以及fc1_bias兩個權重參數，所以在預測前我們必須刪除他們：

my_model <- res_model

my_model$symbol <- flatten0
my_model$arg.params <- my_model$arg.params[names(my_model$arg.params) %in% names(mx.symbol.infer.shape(flatten0, data = c(224, 224, 3, 7))$arg.shapes)]
my_model$aux.params <- my_model$aux.params[names(my_model$aux.params) %in% names(mx.symbol.infer.shape(flatten0, data = c(224, 224, 3, 7))$aux.shapes)]

features <- predict(my_model, X = normed, ctx = mx.cpu())
dim(features)

## [1] 512   1

利用經典模型的model進行預測(5)

我們不可能每次下載一個Pre-training的model後就把它整個Model Architecture都重寫一次，所以我們還可以用這種方法來看看整個模型內有哪些輸出：

#Get features

all_layers = res_sym$get.internals()
tail(all_layers$outputs, 30)

##  [1] "stage4_unit2_bn1_gamma"       "stage4_unit2_bn1_beta"       
##  [3] "stage4_unit2_bn1_moving_mean" "stage4_unit2_bn1_moving_var" 
##  [5] "stage4_unit2_bn1_output"      "stage4_unit2_relu1_output"   
##  [7] "stage4_unit2_conv1_weight"    "stage4_unit2_conv1_output"   
##  [9] "stage4_unit2_bn2_gamma"       "stage4_unit2_bn2_beta"       
## [11] "stage4_unit2_bn2_moving_mean" "stage4_unit2_bn2_moving_var" 
## [13] "stage4_unit2_bn2_output"      "stage4_unit2_relu2_output"   
## [15] "stage4_unit2_conv2_weight"    "stage4_unit2_conv2_output"   
## [17] "_plus7_output"                "bn1_gamma"                   
## [19] "bn1_beta"                     "bn1_moving_mean"             
## [21] "bn1_moving_var"               "bn1_output"                  
## [23] "relu1_output"                 "pool1_output"                
## [25] "flatten0_output"              "fc1_weight"                  
## [27] "fc1_bias"                     "fc1_output"                  
## [29] "softmax_label"                "softmax_output"

我們可以透過這種方式並且把我們想要的層給叫出來

#Get symbol

flatten0_output = which(all_layers$outputs == 'flatten0_output') %>% all_layers$get.output()

my_model <- res_model
my_model$symbol <- flatten0_output
my_model$arg.params <- my_model$arg.params[names(my_model$arg.params) %in% names(mx.symbol.infer.shape(flatten0_output, data = c(224, 224, 3, 7))$arg.shapes)]
my_model$aux.params <- my_model$aux.params[names(my_model$aux.params) %in% names(mx.symbol.infer.shape(flatten0_output, data = c(224, 224, 3, 7))$aux.shapes)]

features <- predict(my_model, X = normed, ctx = mx.cpu())
dim(features)

## [1] 512   1

利用經典模型的model進行預測(6)

如果你願意編寫底層執行器，你甚至能同時輸出feature和預測結果：

flatten0_output = which(all_layers$outputs == 'flatten0_output') %>% all_layers$get.output()
softmax_output = which(all_layers$outputs == 'softmax_output') %>% all_layers$get.output()
out = mx.symbol.Group(c(flatten0_output, softmax_output))
executor = mx.simple.bind(symbol = out, data = c(224, 224, 3, 1), ctx = mx.cpu())

mx.exec.update.arg.arrays(executor, res_model$arg.params, match.name = TRUE)
mx.exec.update.aux.arrays(executor, res_model$aux.params, match.name = TRUE)
mx.exec.update.arg.arrays(executor, list(data = mx.nd.array(normed)), match.name = TRUE)
mx.exec.forward(executor, is.train = FALSE)

features = as.array(executor$ref.outputs$flatten0_output)
dim(features)

## [1] 512   1

prob = as.array(executor$ref.outputs$softmax_output)
cat(paste0(label_names[which.max(prob)], ': ', formatC(max(prob), 4, format = 'f'), '\n'))

## n01818515 macaw: 0.9956

練習1：利用features重現預測結果

請試著利用上面的特徵「features」，並利用resnet-18的全連接層之權重，重新計算出圖片的分類機率。

– 你可能需要從「res_model」裡叫出權重：

PARAMS <- res_model$arg.params
ls(PARAMS)

##  [1] "bn_data_beta"              "bn_data_gamma"            
##  [3] "bn0_beta"                  "bn0_gamma"                
##  [5] "bn1_beta"                  "bn1_gamma"                
##  [7] "conv0_weight"              "fc1_bias"                 
##  [9] "fc1_weight"                "stage1_unit1_bn1_beta"    
## [11] "stage1_unit1_bn1_gamma"    "stage1_unit1_bn2_beta"    
## [13] "stage1_unit1_bn2_gamma"    "stage1_unit1_conv1_weight"
## [15] "stage1_unit1_conv2_weight" "stage1_unit1_sc_weight"   
## [17] "stage1_unit2_bn1_beta"     "stage1_unit2_bn1_gamma"   
## [19] "stage1_unit2_bn2_beta"     "stage1_unit2_bn2_gamma"   
## [21] "stage1_unit2_conv1_weight" "stage1_unit2_conv2_weight"
## [23] "stage2_unit1_bn1_beta"     "stage2_unit1_bn1_gamma"   
## [25] "stage2_unit1_bn2_beta"     "stage2_unit1_bn2_gamma"   
## [27] "stage2_unit1_conv1_weight" "stage2_unit1_conv2_weight"
## [29] "stage2_unit1_sc_weight"    "stage2_unit2_bn1_beta"    
## [31] "stage2_unit2_bn1_gamma"    "stage2_unit2_bn2_beta"    
## [33] "stage2_unit2_bn2_gamma"    "stage2_unit2_conv1_weight"
## [35] "stage2_unit2_conv2_weight" "stage3_unit1_bn1_beta"    
## [37] "stage3_unit1_bn1_gamma"    "stage3_unit1_bn2_beta"    
## [39] "stage3_unit1_bn2_gamma"    "stage3_unit1_conv1_weight"
## [41] "stage3_unit1_conv2_weight" "stage3_unit1_sc_weight"   
## [43] "stage3_unit2_bn1_beta"     "stage3_unit2_bn1_gamma"   
## [45] "stage3_unit2_bn2_beta"     "stage3_unit2_bn2_gamma"   
## [47] "stage3_unit2_conv1_weight" "stage3_unit2_conv2_weight"
## [49] "stage4_unit1_bn1_beta"     "stage4_unit1_bn1_gamma"   
## [51] "stage4_unit1_bn2_beta"     "stage4_unit1_bn2_gamma"   
## [53] "stage4_unit1_conv1_weight" "stage4_unit1_conv2_weight"
## [55] "stage4_unit1_sc_weight"    "stage4_unit2_bn1_beta"    
## [57] "stage4_unit2_bn1_gamma"    "stage4_unit2_bn2_beta"    
## [59] "stage4_unit2_bn2_gamma"    "stage4_unit2_conv1_weight"
## [61] "stage4_unit2_conv2_weight"

請跟prob的結果作比較：

cat(paste0(label_names[which.max(prob)], ': ', formatC(max(prob), 4, format = 'f'), '\n'))

## n01818515 macaw: 0.9956

練習1答案

再做一次FullyConnected以及Softmax就能得出答案，並且能與prob進行比較：

# FullyConnected
FC_COEF = PARAMS$fc1_weight %>% as.array
FC_BIAS = PARAMS$fc1_bias %>% as.array
FC1_out = t(features)%*%FC_COEF + FC_BIAS

# Softmax
new.prob <- exp(FC1_out)/sum(exp(FC1_out))
cat(paste0(label_names[which.max(new.prob)], ': ', formatC(max(new.prob), 4, format = 'f'), '\n'))

## n01818515 macaw: 0.9956

轉移特徵學習(1)

我們一直提到了深度學習領域的三大問題：過度擬合問題、梯度消失問題、權重初始化問題，而其中梯度消失問題明顯是阻礙進步最重要的因素，然而這個問題在2016年起瞬間被有效的解決後，深度學習也迎來了大爆發的時代。

– 而剩下的兩個問題中過度擬合問題有眾多可行的解決方案，或者是我們可以取得更大量的資料解決問題。然而權重初始化問題一直沒有辦法被解決。

由於李飛飛公開了ImageNet並提供裡面的巨量資料供大家試驗他的Model，故網路上有非常多使用那些經典模型在ImageNet上的訓練結果，而上一節的部分我們也有看到，這些免費的模型同樣對於一般任務來說「非常的準」。所以我們有個想法，能不能使用這些經典模型的參數當作初始權重，並在這個基礎上訓練網路完成我們的任務目標。

– 這個想法稱作轉移特徵學習(Transfer learning)，而這個想法是基於人類通常具有舉一反三的能力，舉例來說一個剛入學的醫學系學生他們僅有接受過高中程度的基礎訓練，並未接受過任何醫學專業領域的訓練，但他們的學習因為是基於高中的基礎之上，因此即使醫學專業相當艱深也能相當快的學會。

一般來說，有使用轉移特徵學習的概念先將網路在大資料上學習(主題可以與目標任務幾乎無關)，而後再到目標任務中訓練，其準確度會更好。

F8_39

轉移特徵學習(2)

至於為什麼這樣會成功?這主要是因為人們發現在深度神經網路較淺層的部分，通常只能辨認線條、區塊等基礎特徵，所以無論是用什麼資料訓練網路在前面的部分都是一樣的。而通常要回答一張圖片是什麼，這樣的功能主要是在網路的後端再進行分類，因此在一個比較理想的狀況之下，預先用大資料可以訓練網路較淺層的部分，而之後的小資料能夠協助網路調整後面幾層的權重。

– 讓我們做個小實驗來看看，用剛剛的resnet-18抽取鸚鵡圖並看看第一層的特徵圖長什麼樣子：

my_model <- res_model

my_model$symbol <- relu0
my_model$arg.params <- my_model$arg.params[names(my_model$arg.params) %in% names(mx.symbol.infer.shape(relu0, data = c(224, 224, 3, 7))$arg.shapes)]
my_model$aux.params <- my_model$aux.params[names(my_model$aux.params) %in% names(mx.symbol.infer.shape(relu0, data = c(224, 224, 3, 7))$aux.shapes)]

features <- predict(my_model, X = normed, ctx = mx.cpu())

#Display image

eps = 1e-8
par(mar=rep(0,4), mfrow = c(3, 3))
for (i in 1:9) {
  plot(NA, xlim = c(0.04, 0.96), ylim = c(0.04, 0.96), xaxt = "n", yaxt = "n", bty = "n")
  feature_IMG <- t(features[,,i,])
  feature_IMG <- feature_IMG/(max(feature_IMG) + eps)
  rasterImage(feature_IMG, 0, 0, 1, 1, interpolate=FALSE)
}

再來看看這些卷積器的權重，這是64個最淺層的卷積器希望抓取的特徵：

par(mar=rep(0,4), mfrow = c(8, 8))
for (i in 1:64) {
  plot(NA, xlim = 0:1, ylim = 0:1, xaxt = "n", yaxt = "n", bty = "n")
  feature_IMG <- t(features[,,i,])
  feature_IMG <- feature_IMG/max(feature_IMG)
  rasterImage(as.cimg(as.array(my_model$arg.params$conv0_weight)[,,,i]), 0, 0, 1, 1, interpolate=FALSE)
}

你會發現，其實較淺層的卷積器並沒有辦法把圖片做什麼樣的轉換，而他們所抓取的特徵其實也非常簡單。

轉移特徵學習(3)

在MxNet裡面要做轉移特徵學習也非常簡單，在前面我們已經學會過如何抓取中間的Layer，而抓到這個Layer後我們就能隨意的添加我們想要的結構。

– 舉例來說，我們可以定義我們要整個resnet-18除了最後一個全連接層外的所有結構，只把最後一層的FC從分1000類轉變成分2類：

#Get symbol

all_layers = res_sym$get.internals()
flatten0_output = which(all_layers$outputs == 'flatten0_output') %>% all_layers$get.output()

fc1 <- mx.symbol.FullyConnected(data = flatten0_output, num_hidden = 2, name = 'fc1')
softmax <- mx.symbol.softmax(data = fc1, axis = 1, name = 'softmax')

label = mx.symbol.Variable(name = 'label')

eps = 1e-8
m_log = 0 - mx.symbol.mean(mx.symbol.broadcast_mul(mx.symbol.log(softmax + eps), label))
m_logloss = mx.symbol.MakeLoss(m_log, name = 'm_logloss')

– 接著，我們之前在開始訓練時需要初始化所有參數，我們可以將最後一層以外的部分填入resnet-18的參數，並繼續訓練任務：

mx.set.seed(0)
new_arg = mxnet:::mx.model.init.params(symbol = m_logloss,
                                       input.shape = list(data = c(224, 224, 3, 7), label = c(2, 7)),
                                       output.shape = NULL,
                                       initializer = mxnet:::mx.init.uniform(0.01),
                                       ctx = mx.cpu())

for (i in 1:length(new_arg$arg.params)) {
  pos <- which(names(res_model$arg.params) == names(new_arg$arg.params)[i])
  if (all.equal(dim(res_model$arg.params[[pos]]), dim(new_arg$arg.params[[i]])) == TRUE) {
    new_arg$arg.params[[i]] <- res_model$arg.params[[pos]]
  }
}

for (i in 1:length(new_arg$aux.params)) {
  pos <- which(names(res_model$aux.params) == names(new_arg$aux.params)[i])
  if (all.equal(dim(res_model$aux.params[[pos]]), dim(new_arg$aux.params[[i]])) == TRUE) {
    new_arg$aux.params[[i]] <- res_model$aux.params[[pos]]
  }
}

這樣我們就能在編寫底層執行器時把這些參數填入執行器中，並由此開始訓練：

batch_size = 20

#1. Build an executor to train model
my_executor = mx.simple.bind(symbol = m_logloss,
                             data = c(224, 224, 3, batch_size), label = c(2, batch_size),
                             ctx = mx.cpu(), grad.req = "write")

#2. Set the initial parameters
mx.exec.update.arg.arrays(my_executor, new_arg$arg.params, match.name = TRUE)
mx.exec.update.aux.arrays(my_executor, new_arg$aux.params, match.name = TRUE)

練習2：用轉移特徵學習進行貓狗分類任務

Dogs vs. Cats是Kaggle中的一個經典比賽，目標是希望你能做出一個演算法能夠將貓的圖片與狗的圖片進行分類。

– 讓我們到這裡下載其中的100張貓以及100張狗，最後再用這個分類器預測裡面貓狗各5張測試圖片。

– 這個任務對於你的程式能力會有些挑戰，這些貓狗圖片都完全沒有經過前處理並且有任何角度的照片，你的目標是僅僅使用各100張貓狗圖片就能訓練出一個有一定準確度的模型。

– 如果你有空的話，我們可以比較下列3種情形的準確度差異：

直接使用原始的resnet-18進行預測(ImageNet裡面本來就有貓跟狗的圖片，假設他有猜到貓跟狗的Label就算他對)
使用轉移特徵學習初始化權重，並使用resnet-18的架構進行訓練，最後再來預測
使用隨機初始化的權重，並使用resnet-18的架構進行訓練，最後再來預測

練習2答案(1)

我們這裡只示範使用轉移特徵學習的訓練方法：
讓我們先讀取Data並且進行前處理，並將檔案存成Train_img.array以及Train_Y.array：

library(imager)
library(magrittr)

# Define image processing functions

preproc.image <- function(im) {
  resized <- resize(im, 224, 224)
  resized <- as.array(resized) * 255
  # Reshape to format needed by mxnet (width, height, channel, num)
  dim(resized) <- c(224, 224, 3, 1)
  return(resized)
}

# Read data

Train_img.array <- array(0, dim = c(224, 224, 3, 200))
Train_Y.array <- array(t(model.matrix(~ -1 + factor(rep(1:2, 100)))), dim = c(2, 200))

for (i in 1:100) {
  cat_img <- load.image(paste0('Dogs vs. Cats/cat.', i, '.jpg'))
  Train_img.array[,,,(i-1)*2 + 1] <- preproc.image(cat_img)
  dog_img <- load.image(paste0('Dogs vs. Cats/dog.', i, '.jpg'))
  Train_img.array[,,,i*2] <- preproc.image(dog_img)
}

接著再編寫Iterator以及Optimizer：

library(mxnet)

# Iterator

my_iterator_core = function(batch_size) {
  
  batch = 0
  batch_per_epoch = ncol(Train_Y.array)/batch_size
  
  reset = function() {batch <<- 0}
  
  iter.next = function() {
    batch <<- batch+1
    if (batch > batch_per_epoch) {return(FALSE)} else {return(TRUE)}
  }
  
  value = function() {
    idx = 1:batch_size + (batch - 1) * batch_size
    idx[idx > ncol(Train_Y.array)] = sample(1:ncol(Train_Y.array), sum(idx > ncol(Train_Y.array)))
    data = mx.nd.array(Train_img.array[,,,idx])
    label = mx.nd.array(Train_Y.array[,idx])
    return(list(data = data, label = label))
  }
  
  return(list(reset = reset, iter.next = iter.next, value = value, batch_size = batch_size, batch = batch))
}

my_iterator_func <- setRefClass("Custom_Iter",
                                fields = c("iter", "batch_size"),
                                contains = "Rcpp_MXArrayDataIter",
                                methods = list(
                                  initialize = function(iter, batch_size = 100){
                                    .self$iter <- my_iterator_core(batch_size = batch_size)
                                    .self
                                  },
                                  value = function(){
                                    .self$iter$value()
                                  },
                                  iter.next = function(){
                                    .self$iter$iter.next()
                                  },
                                  reset = function(){
                                    .self$iter$reset()
                                  },
                                  finalize=function(){
                                  }
                                )
)

my_iter = my_iterator_func(iter = NULL, batch_size = 10)

# Optimizer

my_optimizer = mx.opt.create(name = "sgd", learning.rate = 0.05, momentum = 0.9, wd = 0)

練習2答案(2)

接著讓我們讀取resnet-18並定義新的Model Architecture：

# Read Pre-training Model

res_model = mx.model.load("model/resnet-18", 0)
res_sym = mx.symbol.load("model/resnet-18-symbol.json")

# Get symbol

all_layers = res_sym$get.internals()
flatten0_output = which(all_layers$outputs == 'flatten0_output') %>% all_layers$get.output()

# Define Model Architecture

fc1 <- mx.symbol.FullyConnected(data = flatten0, num_hidden = 2, name = 'fc1')
softmax <- mx.symbol.softmax(data = fc1, axis = 1, name = 'softmax')

label = mx.symbol.Variable(name = 'label')

eps = 1e-8
m_log = 0 - mx.symbol.mean(mx.symbol.broadcast_mul(mx.symbol.log(softmax + eps), label))
m_logloss = mx.symbol.MakeLoss(m_log, name = 'm_logloss')

接著把resnet-18既有的權重填進去(fc1的權重由於最後一層的shape不一樣，所以不能填)：

mx.set.seed(0)
new_arg = mxnet:::mx.model.init.params(symbol = m_logloss,
                                       input.shape = list(data = c(224, 224, 3, 7), label = c(2, 7)),
                                       output.shape = NULL,
                                       initializer = mxnet:::mx.init.uniform(0.01),
                                       ctx = mx.cpu())

for (i in 1:length(new_arg$arg.params)) {
  pos <- which(names(res_model$arg.params) == names(new_arg$arg.params)[i])
  if (all.equal(dim(res_model$arg.params[[pos]]), dim(new_arg$arg.params[[i]])) == TRUE) {
    new_arg$arg.params[[i]] <- res_model$arg.params[[pos]]
  }
}

for (i in 1:length(new_arg$aux.params)) {
  pos <- which(names(res_model$aux.params) == names(new_arg$aux.params)[i])
  if (all.equal(dim(res_model$aux.params[[pos]]), dim(new_arg$aux.params[[i]])) == TRUE) {
    new_arg$aux.params[[i]] <- res_model$aux.params[[pos]]
  }
}

接著我們可以簡單的編寫底層執行器並用迴圈進行訓練：

#1. Build an executor to train model

my_executor = mx.simple.bind(symbol = m_logloss,
                             data = c(224, 224, 3, 10), label = c(2, 10),
                             ctx = mx.cpu(), grad.req = "write")

#2. Set the initial parameters

mx.exec.update.arg.arrays(my_executor, new_arg$arg.params, match.name = TRUE)
mx.exec.update.aux.arrays(my_executor, new_arg$aux.params, match.name = TRUE)

#3. Define the updater

my_updater = mx.opt.get.updater(optimizer = my_optimizer, weights = my_executor$ref.arg.arrays)

開始進行訓練(這邊只是示範，所以準確度並不是非常高，你可以試試看多訓練幾代)：

for (i in 1:3) {
  
  my_iter$reset()
  batch_loss = NULL
  
  while (my_iter$iter.next()) {
    
    my_values <- my_iter$value()
    mx.exec.update.arg.arrays(my_executor, arg.arrays = my_values, match.name = TRUE)
    mx.exec.forward(my_executor, is.train = TRUE)
    mx.exec.backward(my_executor)
    update_args = my_updater(weight = my_executor$ref.arg.arrays, grad = my_executor$ref.grad.arrays)
    mx.exec.update.arg.arrays(my_executor, update_args, skip.null = TRUE)
    batch_loss = c(batch_loss, as.array(my_executor$ref.outputs$m_logloss_output))
    
  }
  
  message(paste0("epoch = ", i, ": m-logloss = ", formatC(mean(batch_loss), format = "f", 4)))
  
}

練習2答案(3)

讓我們用這個模型來預測10張測試集的貓狗圖片(綠色的字是AI認為是貓咪的機率)：

# Get model

dog_cat_model <- mxnet:::mx.model.extract.model(symbol = softmax,
                                                train.execs = list(my_executor))

# Predict & Display

par(mar=rep(0,4), mfcol = c(2, 5))

for (i in 1:5) {
  
  plot(NA, xlim = c(0.04, 0.96), ylim = c(0.04, 0.96), xaxt = "n", yaxt = "n", bty = "n")
  cat_img <- load.image(paste0('Dogs vs. Cats/test_cat.', i, '.jpg'))
  norm_cat_img <- preproc.image(cat_img)
  rasterImage(cat_img, 0, 0, 1, 1, interpolate=FALSE)
  prob <- predict(dog_cat_model, X = norm_cat_img, ctx = mx.cpu())
  text(0.5, 0.95, formatC(prob[1,1], 3, format = 'f'), col = "green", cex = 2)
  
  plot(NA, xlim = c(0.04, 0.96), ylim = c(0.04, 0.96), xaxt = "n", yaxt = "n", bty = "n")
  dog_img <- load.image(paste0('Dogs vs. Cats/test_dog.', i, '.jpg'))
  norm_dog_img <- preproc.image(dog_img)
  rasterImage(dog_img, 0, 0, 1, 1, interpolate=FALSE)
  prob <- predict(dog_cat_model, X = norm_dog_img, ctx = mx.cpu())
  text(0.5, 0.95, formatC(prob[1,1], 3, format = 'f'), col = "green", cex = 2)
  
}

練習2答案(4)

事實上，我們還能指定在訓練過程中固定住前面所有的參數，只重新訓練最後一層的結果，為此我們必須要把執行器多增加一個參數：

Fixed_NAMES = names(res_model$arg.params)[names(res_model$arg.params) %in% names(mx.symbol.infer.shape(flatten0_output, data = c(224, 224, 3, 10))$arg.shapes)]

#1. Build an executor to train model

my_executor = mx.simple.bind(symbol = m_logloss, fixed.param = Fixed_NAMES,
                             data = c(224, 224, 3, 10), label = c(2, 10),
                             ctx = mx.cpu(), grad.req = "write")

#2. Set the initial parameters

mx.exec.update.arg.arrays(my_executor, new_arg$arg.params, match.name = TRUE)
mx.exec.update.aux.arrays(my_executor, new_arg$aux.params, match.name = TRUE)

#3. Define the updater

my_updater = mx.opt.get.updater(optimizer = my_optimizer, weights = my_executor$ref.arg.arrays)

後面的過程完全一樣，讓我們再訓練一次：

for (i in 1:3) {
  
  my_iter$reset()
  batch_loss = NULL
  
  while (my_iter$iter.next()) {
    
    my_values <- my_iter$value()
    mx.exec.update.arg.arrays(my_executor, arg.arrays = my_values, match.name = TRUE)
    mx.exec.forward(my_executor, is.train = TRUE)
    mx.exec.backward(my_executor)
    update_args = my_updater(weight = my_executor$ref.arg.arrays, grad = my_executor$ref.grad.arrays)
    mx.exec.update.arg.arrays(my_executor, update_args, skip.null = TRUE)
    batch_loss = c(batch_loss, as.array(my_executor$ref.outputs$m_logloss_output))
    
  }
  
  message(paste0("epoch = ", i, ": m-logloss = ", formatC(mean(batch_loss), format = "f", 4)))
  
}

你是不是發現快了非常多，而且也準了非常多！

– 使用固定參數需要在Get model時再將固定的參數放入model中：

# Get model

dog_cat_model <- mxnet:::mx.model.extract.model(symbol = softmax,
                                                train.execs = list(my_executor))

dog_cat_model$arg.params <- append(dog_cat_model$arg.params, res_model$arg.params[names(res_model$arg.params) %in%Fixed_NAMES])

# Predict & Display

par(mar=rep(0,4), mfcol = c(2, 5))

for (i in 1:5) {
  
  plot(NA, xlim = c(0.04, 0.96), ylim = c(0.04, 0.96), xaxt = "n", yaxt = "n", bty = "n")
  cat_img <- load.image(paste0('Dogs vs. Cats/test_cat.', i, '.jpg'))
  norm_cat_img <- preproc.image(cat_img)
  rasterImage(cat_img, 0, 0, 1, 1, interpolate=FALSE)
  prob <- predict(dog_cat_model, X = norm_cat_img, ctx = mx.cpu())
  text(0.5, 0.95, formatC(prob[1,1], 3, format = 'f'), col = "green", cex = 2)
  
  plot(NA, xlim = c(0.04, 0.96), ylim = c(0.04, 0.96), xaxt = "n", yaxt = "n", bty = "n")
  dog_img <- load.image(paste0('Dogs vs. Cats/test_dog.', i, '.jpg'))
  norm_dog_img <- preproc.image(dog_img)
  rasterImage(dog_img, 0, 0, 1, 1, interpolate=FALSE)
  prob <- predict(dog_cat_model, X = norm_dog_img, ctx = mx.cpu())
  text(0.5, 0.95, formatC(prob[1,1], 3, format = 'f'), col = "green", cex = 2)
  
}

結語

這週我們講述了深度神經網路的歷史，並且學習了如何利用經典模型進行轉移特徵學習。

– 深度學習的三大經典理論問題(過度擬合問題、梯度消失問題、權重初始化問題)我們都已經大致上學會了該如何應對，並且我們都已經有一些基礎的能力編寫程式訓練出一個AI模型進行圖像分類。

值得一提的是在這次最後的練習中(貓狗分類任務)，你首次面對了較接近真實世界的資料，而非精心整理過的範例資料。

– 這裡要派給各位一個回家作業，作業內容是到Kaggle上的Dogs vs. Cats下載全部的Training data，並且預測測試集的資料後將答案投稿至Kaggle上看看自己的排名。

F8_40

– 這是利用剛剛100個樣本訓練3代後所得到的分數：

F8_41

– 在這個作業中，之前課程中所學到的所有技巧都「有機會」增加準確度。你可以先上網下載一個你最喜歡的經典模型，並以他為基礎進行轉移特徵學習，之後運用所有我們已經學到防止過擬合的所有手段，最後再看看準確度如何！